/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:张熳
 * Date:2025-08-12
 * Time:20:01
 */
//方法的使用及递归

public class Test {
    public static void main(String[] args) {
        //使用循环求斐波那契数列
        System.out.println(fiB(1));//1
        System.out.println(fiB(5));//5
        System.out.println(fiB(10));//55
        System.out.println(fiB(40));//102334155
    }
    public static int fiB(int n){
        int f1 = 1;
        int f2 = 1;
        int f3 = 1;
        for (int i = 3; i <= n; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
    public static void main11(String[] args) {
        //求斐波那契数列的第 N 项      用递归求斐波那契数列其实效率并不高，因为它在递归的过程有许多重复的地方，使用循环求解更高效
        System.out.println(fib(1));//1
        System.out.println(fib(5));//5
        System.out.println(fib(10));//55
        System.out.println(fib(40));//102334155

    }
    public static int fib(int n){
        if (n == 1 || n == 2){
            return 1;
        }
        return fib(n-1) + fib(n-2);
    }
    public static void main10(String[] args) {
        //写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回
        //1+7+2+9，它的和是19
        System.out.println(suM(1729));
    }
    public static int suM(int n){
        if (n < 10){
            return n;
        }
        return suM(n/10) + n%10;
    }
    public static void main9(String[] args) {
        //递归求 1 + 2 + 3 + ... + 10
        System.out.println(sum(10));//55
    }
    public static int sum(int n){
        if (n == 0){
            return 0;
        }
        return n+sum(n-1);
    }
    public static void main8(String[] args) {
        //按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)
        print(1234);
    }
    public static void print(int n){
        if (n < 10){
            System.out.print(n + " ");
            return;
        }
        print(n/10);
        System.out.print(n%10 + " ");
    }
    public static void main7(String[] args) {
        //递归
        //递归求 N 的阶乘
        int n = 5;
        int ret = factor(n);
        System.out.println("ret = " + ret);//120
    }
    public static int factor(int n){
        if (n == 1){
            return 1;
        }
        return n*factor(n-1);
    }

    /*public static double add(int a,int b){
        return a+b;//只是返回值类型不同不构成重载，重载与返回值类型无关
    }*/
    public static int add(int a,int b){    //两个int参数
        return a+b;
    }
    public static double add(double a,double b){   //double参数（参数类型不同）
        return a+b;
    }
    public static int add(int a,int b,int c){   //三个int参数（参数数量不同）
        return a+b+c;
    }
    /*public static int add(int a,int c,int b){    //必须是不同类型的顺序不同
        return a+b+c;
    }*/
    public static int add(int a,int b,short c){
        return a+b+c;
    }
    public static int add(int a,short c,int b){
        return a+b+c;
    }
    public static void main6(String[] args) {
        //但是每一种类型都取一个专门的方法名不太友好，这时候就体现了 方法重载  的作用：
        //方法名相同，参数列表不同（个数/类型/顺序-必须是不同类型的顺序不同），与返回类型是否相同无关
        int x = 1;
        int y = 2;
        int ret = add(x,y);
        System.out.println(ret);

        double d1 = 1.0;
        double d2 = 2.0;
        double ret1 = add(d1,d2);
        System.out.println(ret1);
    }
    public static int addInt(int a,int b){
        return a+b;
    }
    public static double addDouble(double a,double b){
        return a+b;
    }
    public static void main5(String[] args) {
        //方法重载
        int x = 1;
        int y = 2;
        int ret = addInt(x,y);
        System.out.println(ret);

        double d1 = 1.0;
        double d2 = 2.0;
        //double ret1 = add(d1,d2);//类型不兼容,不能使用现有的add方法，一般解决方式都是每个类型创建一个方法并取一个专门的方法名
        double ret1 = addDouble(d1,d2);
        System.out.println(ret1);
    }
    public static void swap(int a,int b){
        int tmp = a;
        a = b;
        b = tmp;
    }
    public static void main4(String[] args) {
        //实现一个两个整数的交换方法
        int x = 10;
        int y = 20;
        swap(x,y);//此时传回来后实参也是并没有发生改变，解决方法就是使用引用类型参数（如数组）来解决
        System.out.println(x + " " + y);
    }
    public static void func(int year){
        year = 100;
    }
    public static void main3(String[] args) {
        //形参的改变不会影响实参
        int year = 2008;
        //&year;   java拿不到栈上的局部变量的地址，不能像C语言一样取地址操作来改变实参的值
        func(2008);
        System.out.println(year);
    }

    public static void main2(String[] args) {
        //计算 1! + 2! + 3! + 4! + 5!
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += fac(i);
        }
        System.out.println(sum);//153
    }
    public static int fac(int n){
        int ret = 1;
        for (int j = 1; j <= n; j++) {
            ret *= j;
        }
        return ret;
    }
    public static boolean isleapYear(int year){
        if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
            return true;
        }else {
            return false;
        }
    }
    public static void main1(String[] args) {
        //实现一个函数，检测一个年份是否为闰年
        boolean ret = isleapYear(2008);
        if (ret == true){
            System.out.println("是闰年!");
        }
    }
}
